#!/bin/sh
# **********************************************************************
# Trabajo Practico de Sistemas Operativos
# Curso Martes
# Comando: instalars.bash
# Descripción: comando encargado de realizar la instalacion del paquete.
#
# Codigos de Salida:
# 0: Ejecucion Correcta.
# 1: Ejecución Incorrecta.
# **********************************************************************

# Usuario y fecha en que se realiza la instalacion.
DATE=`date "+%Y-%m-%dT%H:%M:%S"`
USERID=`whoami`
QUICK_INSTALL=0

# Directorios por defecto.
CURRDIR=$(pwd | sed s*inst**)
CONF_DIR=${CURRDIR}conf
DATA_DIR=${CURRDIR}data
LOG_DIR=${CURRDIR}log
BIN_DIR=${CURRDIR}bin
COMMANDS_DIR=$(pwd)/commands/
MOVER_CMD=mover.bash

# Otros parametros de configuracion.
FORM_LOG="\$\(date +%d/%m/%y\ %T\)-\$\(whoami\)-"
FORM_ERR="\$\(date +%d/%m/%y\ %T\)-\$\(whoami\)-\${0##*/}-"
ERR_FILE=${CONF_DIR}/error.log

# Archivo de configuracion.
CONF_FILE=${CONF_DIR}/segmentar.conf

# Archivo de log.
LOG_FILE=${CONF_DIR}/instalars.log

# Formato de log.
LOG_DEBUG=$(date +%d/%m/%y\ %T)-$(whoami)-

# Mensaje generico de fin de instalacion.
ERROR_MSG="Proceso de instalacion cancelado."

# Variables para version de perl y maximo tamaño de logs.
PERLVER=0
MAX_LOG_SIZE=0

# Variables para determinar componentes instalados.
INSTALLED=0
ALL_INSTALLED=0
TRUNCAR_INSTALLED=0
DETECTAR_INSTALLED=0
AUDITAR_INSTALLED=0
INICIAR_INSTALLED=0
SEGMENTAR_INSTALLED=0
DEFINDED_DATA_DIR=0
DEFINDED_LOG_DIR=0
DEFINDED_MAX_LOG_SIZE=0

# Variales para determinar que componentes instalar.
INSTALL_TRUNCAR=1
INSTALL_DETECTAR=1
INSTALL_AUDITAR=1
INSTALL_INICIAR=1
INSTALL_SEGMENTAR=1

# Nombre por defecto del directorio, script, usuario y fecha de TRUNCAR.
TRUNCAR_DEFAULT_CMD=truncar.bash
TRUNCAR_CMD=$TRUNCAR_DEFAULT_CMD
TRUNCAR_BINDIR=$BIN_DIR
USER_TRUNCAR=$USERID
DATE_TRUNCAR=$DATE

# Nombre por defecto del directorio, script, usuario y fecha de DETECTAR.
DETECTAR_DEFAULT_CMD=detectar.bash
DETECTAR_CMD=$DETECTAR_DEFAULT_CMD
DETECTAR_BINDIR=$BIN_DIR
USER_DETECTAR=$USERID
DATE_DETECTAR=$DATE

# Nombre por defecto del directorio, script, usuario y fecha de AUDITAR.
AUDITAR_DEFAULT_CMD=auditar.bash
AUDITAR_CMD=$AUDITAR_DEFAULT_CMD
AUDITAR_BINDIR=$BIN_DIR
USER_AUDITAR=$USERID
DATE_AUDITAR=$DATE

# Nombre por defecto del directorio, script, usuario y fecha de INICIAR.
INICIAR_DEFAULT_CMD=iniciar.bash
INICIAR_CMD=$INICIAR_DEFAULT_CMD
INICIAR_BINDIR=$BIN_DIR
USER_INICIAR=$USERID
DATE_INICIAR=$DATE

# Nombre por defecto del directorio, script, usuario y fecha de SEGMENTAR.
SEGMENTAR_DEFAULT_CMD=segmentar.pl
SEGMENTAR_CMD=$SEGMENTAR_DEFAULT_CMD
SEGMENTAR_BINDIR=$BIN_DIR
USER_SEGMENTAR=$USERID
DATE_SEGMENTAR=$DATE

# SleepTime por defecto de truncar y detecar.
TRUNCAR_DEFAULT_SLEEP=5
SLEEP_TRUNCAR=$TRUNCAR_DEFAULT_SLEEP
DETECTAR_DEFAULT_SLEEP=1
SLEEP_DETECTAR=$DETECTAR_DEFAULT_SLEEP

######################################################### Funciones #########################################################

# Loguear en consola y archivo.
function log() {
	echo $*
	echo $LOG_DEBUG$* >> $LOG_FILE
}

# Loguear solamente en archivo.
function logDebug() {
	echo $LOG_DEBUG$* >> $LOG_FILE
}

# Loguear fin de instalacion.
function logFin() {
	log $ERROR_MSG
	exit 0
}

# Validar nombre.
function isValidName() {
	logDebug "Validando nombre: $1"
	echo $1 | egrep -q '^[[:alnum:]]+$'
}

# Validar entero.
function isValidNumber() {
	logDebug "Validando numero: $1"
	echo $1 | egrep '^[0-9]+$'
}

# Mostrar terminos y condiciones.
function showTermsAndConditions() {
	log "========================================================"
	log ".........Proceso de Instalacion de \"Segmentar\".........."
	log "............Copyright TPSistemasOP (c) 2009............."
	log "========================================================"
	log ""
	log "A T E N C I O N: Al instalar Segmentar UD. expresa"
	log "aceptar los terminos y condiciones del \"ACUERDO DE"
	log "LICENCIA DE SOFTWARE\" incluido en este paquete."
	log ""
}

# Confirmacion de usuario.
function promptForConfirmation() {
	log $*

	read input
	logDebug $input
	while [ "$input" != "Si" -a "$input" != "No" ] && [ ! -z $input ]
	do
		echo $*
	  	read input
		logDebug $input
	done

	if [ -z $input ] || [ $input = "Si" ]
	then
		return 0
	else
		return 1
	fi
}

# Verificar version de perl.
function checkPerlVersion() {
	logDebug "Verificando version de Perl instalada..."
	PERLVER=`perl -v | sed -n "s/.*v\([0-9]\).*/\1/p"`

	if [ $PERLVER -lt 5 ]
	then
		log "ATENCION! Esta instalacion solo puede ser ejecutada si Perl 5 o superior esta instalado."
		log "Efectue la instalacion de Perl y reinicie el proceso de instalacion."
		logFin
	else
		logDebug "Verificando version de Perl instalada... Version $PERLVER Ok."
	fi
}

# Verificar que exista directorio y archivo.
function checkInstalledCommand() {
	if [ ! -z $1 ] && [ ! -z $2 ]
	then
		if [ -d $1 -a -e $1/$2 ]
		then
			logDebug "Verificando existencia de $1/$2... Existe."
			return 0
		else
			logDebug "Verificando existencia de $1/$2... No Existe."
			return 1
		fi
	else
		return 1
	fi
}

# Detectar componentes instalados.
function checkInstalledComponents() {
	logDebug "Chequeando Componentes Instalados..."

	if [ -e $CONF_FILE ] 
	then

		if [ ! -z $(sed -n '2p' $CONF_FILE | sed 's*DATADIR = **') ]
		then
			DATA_DIR=$(sed -n '2p' $CONF_FILE | sed 's*DATADIR = **')
			DEFINDED_DATA_DIR=1
			logDebug "DATADIR definida de instalacion previa: $DATA_DIR"				
		fi

		if [ ! -z $(sed -n '3p' $CONF_FILE | sed 's*LOGDIR = **') ]
		then
			LOG_DIR=$(sed -n '3p' $CONF_FILE | sed 's*LOGDIR = **')
			DEFINDED_LOG_DIR=1
			logDebug "LOGDIR definida de instalacion previa: $LOG_DIR"
		fi

		if [ ! -z $(sed -n '4p' $CONF_FILE | sed 's*MAXLOGSIZE = **') ]
		then 
			MAX_LOG_SIZE=$(sed -n '4p' $CONF_FILE | sed 's*MAXLOGSIZE = **')
			DEFINDED_MAX_LOG_SIZE=1
			logDebug "MAXLOGSIZE definida de instalacion previa: $MAX_LOG_SIZE"
		fi

		TRUNCAR_BINDIR=$(sed -n '11p' $CONF_FILE | sed 's*BINDIR = **')
		INICIAR_BINDIR=$(sed -n '16p' $CONF_FILE | sed 's*BINDIR = **')
		AUDITAR_BINDIR=$(sed -n '21p' $CONF_FILE | sed 's*BINDIR = **')
		DETECTAR_BINDIR=$(sed -n '26p' $CONF_FILE | sed 's*BINDIR = **')
		SEGMENTAR_BINDIR=$(sed -n '31p' $CONF_FILE | sed 's*BINDIR = **')

		TRUNCAR_CMD=$(sed -n '10p' $CONF_FILE | sed 's*TRUNCAR = **')
		INICIAR_CMD=$(sed -n '15p' $CONF_FILE | sed 's*INICIAR = **')
		AUDITAR_CMD=$(sed -n '20p' $CONF_FILE | sed 's*AUDITAR = **')
		DETECTAR_CMD=$(sed -n '25p' $CONF_FILE | sed 's*DETECTAR = **')
		SEGMENTAR_CMD=$(sed -n '30p' $CONF_FILE | sed 's*segmentar.pl = **')

		if checkInstalledCommand $TRUNCAR_BINDIR $TRUNCAR_CMD
		then
			TRUNCAR_INSTALLED=1
			INSTALL_TRUNCAR=0
			INSTALLED=1
			USER_TRUNCAR=$(sed -n '12p' $CONF_FILE | sed 's*USERID = **')
			DATE_TRUNCAR=$(sed -n '13p' $CONF_FILE | sed 's*FECINS = **')
			SLEEP_TRUNCAR=$(sed -n '14p' $CONF_FILE | sed 's*SLEEPT = **')
			logDebug "TRUNCAR Instalado: $USER_TRUNCAR $DATE_TRUNCAR $SLEEP_TRUNCAR"
		fi

		if checkInstalledCommand $INICIAR_BINDIR $INICIAR_CMD 
		then
			INICIAR_INSTALLED=1
			INSTALL_INICIAR=0
			INSTALLED=1
			USER_INICIAR=$(sed -n '17p' $CONF_FILE | sed 's*USERID = **')
			DATE_INICIAR=$(sed -n '18p' $CONF_FILE | sed 's*FECINS = **')
			logDebug "INICIAR Instalado: $USER_INICIAR $DATE_INICIAR"
		fi

		if checkInstalledCommand $AUDITAR_BINDIR $AUDITAR_CMD
		then
			AUDITAR_INSTALLED=1
			INSTALL_AUDITAR=0
			INSTALLED=1
			USER_AUDITAR=$(sed -n '22p' $CONF_FILE | sed 's*USERID = **')
			DATE_AUDITAR=$(sed -n '23p' $CONF_FILE | sed 's*FECINS = **')
			logDebug "AUDITAR Instalado: $USER_AUDITAR $DATE_AUDITAR"
		fi

		if checkInstalledCommand $DETECTAR_BINDIR $DETECTAR_CMD
		then
			DETECTAR_INSTALLED=1
			INSTALL_DETECTAR=0
			INSTALLED=1
			USER_DETECTAR=$(sed -n '27p' $CONF_FILE | sed 's*USERID = **')
			DATE_DETECTAR=$(sed -n '28p' $CONF_FILE | sed 's*FECINS = **')
			SLEEP_DETECTAR=$(sed -n '29p' $CONF_FILE | sed 's*SLEEPD = **')
			logDebug "DETECTAR Instalado: $USER_DETECTAR $DATE_DETECTAR $SLEEP_DETECTAR"
		fi

		if checkInstalledCommand $SEGMENTAR_BINDIR $SEGMENTAR_CMD
		then
			SEGMENTAR_INSTALLED=1
			INSTALL_SEGMENTAR=0
			INSTALLED=1
			USER_SEGMENTAR=$(sed -n '32p' $CONF_FILE | sed 's*USERID = **')
			DATE_SEGMENTAR=$(sed -n '33p' $CONF_FILE | sed 's*FECINS = **')
			logDebug "SEGMENTAR Instalado: $USER_SEGMENTAR $DATE_SEGMENTAR"
		fi

		# Si estan todos los componentes instalados.
		if [ $TRUNCAR_INSTALLED -eq 1 ] && [ $INICIAR_INSTALLED -eq 1 ] && [ $AUDITAR_INSTALLED -eq 1 ] && [ $DETECTAR_INSTALLED -eq 1 ] && [ $SEGMENTAR_INSTALLED -eq 1 ]
		then
			ALL_INSTALLED=1
			log "========================================================"
			log "Se han detectado los siguientes componentes instalados:"
			log "Componente segmentar.pl: $SEGMENTAR_BINDIR/$SEGMENTAR_CMD $DATE_SEGMENTAR $USER_SEGMENTAR"
			log "Componente INICIAR: $INICIAR_BINDIR/$INICIAR_CMD $DATE_INICIAR $USER_INICIAR"
			log "Componente AUDITAR: $AUDITAR_BINDIR/$AUDITAR_CMD $DATE_AUDITAR $USER_AUDITAR"
			log "Componente TRUNCAR: $TRUNCAR_BINDIR/$TRUNCAR_CMD $DATE_TRUNCAR $USER_TRUNCAR"
			log "Componente DETECTAR: $DETECTAR_BINDIR/$DETECTAR_CMD $DATE_DETECTAR $USER_DETECTAR"
			log ""
			log ""
			log "Copyrigth TPSistemasOP (c) 2009"
			log "========================================================"
		elif [ $INSTALLED -eq 1 ]
		then
			log "========================================================"
			log "Se han detectado componentes instalados y faltantes:"

			if [ $SEGMENTAR_INSTALLED -eq 1 ]
			then
				log "Componente segmentar.pl: Instalado por $USER_SEGMENTAR, $DATE_SEGMENTAR "
			else
				log "Componente segmentar.pl: No instalado."
				SEGMENTAR_BINDIR=$BIN_DIR
				SEGMENTAR_CMD=$SEGMENTAR_DEFAULT_CMD
			fi

			if [ $INICIAR_INSTALLED -eq 1 ]
			then
				log "Componente INICIAR: Instalado por $USER_INICIAR, $DATE_INICIAR "
			else
				log "Componente INICIAR: No instalado."
				INICIAR_BINDIR=$BIN_DIR
				INICIAR_CMD=$INICIAR_DEFAULT_CMD
			fi

			if [ $AUDITAR_INSTALLED -eq 1 ]
			then
				log "Componente AUDITAR: Instalado por $USER_AUDITAR, $DATE_AUDITAR "
			else
				log "Componente AUDITAR: No instalado."
				AUDITAR_BINDIR=$BIN_DIR
				AUDITAR_CMD=$AUDITAR_DEFAULT_CMD
			fi

			if [ $TRUNCAR_INSTALLED -eq 1 ]
			then
				log "Componente TRUNCAR: Instalado por $USER_TRUNCAR, $DATE_TRUNCAR "
			else
				log "Componente TRUNCAR: No instalado."
				TRUNCAR_BINDIR=$BIN_DIR
				TRUNCAR_CMD=$TRUNCAR_DEFAULT_CMD
				SLEEP_TRUNCAR=$TRUNCAR_DEFAULT_SLEEP
			fi

			if [ $DETECTAR_INSTALLED -eq 1 ]
			then
				log "Componente DETECTAR: Instalado por $USER_DETECTAR, $DATE_DETECTAR "
			else
				log "Componente DETECTAR: No instalado."
				DETECTAR_BINDIR=$BIN_DIR
				DETECTAR_CMD=$DETECTAR_DEFAULT_CMD
				SLEEP_DETECTAR=$DETECTAR_DEFAULT_SLEEP
			fi

			log ""
			log ""
			log "Copyrigth TPSistemasOP (c) 2009"
			log "========================================================"
		fi
	else
		logDebug "Chequeando Componentes Instalados... No existe el archivo de configuracion."
	fi
}

# Mostrar espacio disponible en directorio de datos.
function calculateFreeSpace() {
	disk_space=$(df -k $1 | grep -v "Filesystem" | awk '{print $4}' | tail -n1)	
	free_space=$(echo "$disk_space / 1024" | bc)
}

# Setear y verificar directorio de datos.
function checkDataFolder() {
	logDebug "Chequeando directorio de datos..."

	# Directorio de datos (solamente si no es esta ya definido en la configuracion).
	if [ $DEFINDED_DATA_DIR -eq 0 ]
	then	
		ok=1
		while [ $ok != 0 ]
		do
			log "Nombre del directorio de datos: (${DATA_DIR})"
			read datadir
			logDebug $datadir

			if isValidName "$datadir"
			then
				DATA_DIR=$CURRDIR$datadir
				ok=0
			elif [ -z $datadir ]
			then
				ok=0
			fi
		done
		logDebug "Directorio de datos selecionado: ${DATA_DIR}"
	fi

	logDebug "Chequeando directorio de datos... Done."
}

# Verificar y confirmar (usuario) espacio libre para datos.
function checkDataFolderSpace() {
	logDebug "Calculando estpacio disponible..."

	# Espacio libre.
	calculateFreeSpace $CURRDIR
	DATA_SIZE=$free_space
	log "Espacio disponible en $DATA_DIR: $DATA_SIZE Mb"

	logDebug "Calculando estpacio disponible... Done."

	if ! promptForConfirmation "Desea Continuar? (Si) : Si - No"
	then
		logFin
	fi
}

# Verificar directorio de logs.
function checkLogFolder() {
	logDebug "Chequeando directorio de logs..."

	# Directorio de logs (solamente si no esta ya definido en la configuracion).
	if [ $DEFINDED_LOG_DIR -eq 0 ]
	then
		# Directorio de logs.
		ok=1
		while [ $ok != 0 ]
		do
			log "Nombre del directorio de log: (${LOG_DIR})"
			read logdir
			logDebug $logdir

			if isValidName "$logdir"
			then
				LOG_DIR=$CURRDIR$logdir
				ok=0
			elif [ -z $logdir ]
			then
				ok=0
			fi
		done
		logDebug "Directorio de logs selecionado: ${LOG_DIR}"
	fi

	logDebug "Chequeando directorio de logs... Done."
}

# Verificar maximo espacio para logs.
function checkMaxLogSize() {
	logDebug "Chequeando maximo espacio para logs..."

	# Maximo espacio destinado a logs (solamente si no esta ya definido en la configuracion).
	if [ $DEFINDED_MAX_LOG_SIZE -eq 0 ]
	then
		
		if [ $1 -eq 0 ]
		then
			MAX_LOG_SIZE=`echo "$DATA_SIZE / 10" | bc`
		fi

		ok=1
		while [ $ok != 0 ]
		do
			log "Espacio maximo para archivos de log? ($MAX_LOG_SIZE) Mb:"
			read maxLogSize
			logDebug $maxLogSize

			if [ -z $maxLogSize ]
			then
				ok=0
			elif isValidNumber "$maxLogSize"
			then
				if [ $maxLogSize -le $MAX_LOG_SIZE ]
				then
					MAX_LOG_SIZE=$maxLogSize
					ok=0
				else
					log "Espacio maximo para archivos de log permitido: $MAX_LOG_SIZE Mb"
				fi
			fi
		done

		logDebug "Espacio maximo para archivos de logs seleccionado: $MAX_LOG_SIZE Mb"
	fi

	logDebug "Chequeando maximo espacio para logs... Done"
}

# Verificar directorio para ejecutables.
function checkExecutableFolder() {
	# Directorio de ejecutables.
	ok=1
	while [ $ok != 0 ]
	do
		log "Nombre del directorio de ejecutables: (${BIN_DIR})"
		read bindir
		logDebug $bindir

		if isValidName "$bindir"
		then
			BIN_DIR=$CURRDIR$bindir
			ok=0
		elif [ -z $bindir ]
		then
			ok=0
		fi
	done
	logDebug "Directorio de ejecutables selecionado: ${BIN_DIR}"
}

# Chequear si el primer parametro es alguno de los otros parametros.
function isIncluded() {
	PARAM=$1
	shift

	while [ $# -ne 0 ]
	do
		if [ $PARAM = $1 ]
		then
			return 0
		fi
		shift
	done

	return 1
}

# Verificar y loguear si un componente ya esta inslado. Se utiliza para la instalacion unitaria.
function checkComponentForInstall() {
	if [ $1 -eq 1 ]	
	then
		log "El componente ya se encuentra instalado en el sistema."
		logFin
	fi
}

# Anular las variables de los componentes pasados por parametro. 
function unsetComponentVariables() {
	logDebug "Deshabilitando componentes $1 $2 $3 $4..."

	if [ $TRUNCAR_INSTALLED -eq 0 ] && isIncluded "TRUNCAR" $1 $2 $3 $4
	then
		INSTALL_TRUNCAR=0
		TRUNCAR_CMD=""
		TRUNCAR_BINDIR=""
		USER_TRUNCAR=""
		DATE_TRUNCAR=""
		SLEEP_TRUNCAR=""
	fi

	if [ $DETECTAR_INSTALLED -eq 0 ] && isIncluded "DETECTAR" $1 $2 $3 $4
	then
		INSTALL_DETECTAR=0
		DETECTAR_CMD=""
		DETECTAR_BINDIR=""
		USER_DETECTAR=""
		DATE_DETECTAR=""
		SLEEP_DETECTAR=""
	fi

	if [ $AUDITAR_INSTALLED -eq 0 ] && isIncluded "AUDITAR" $1 $2 $3 $4
	then
		INSTALL_AUDITAR=0
		AUDITAR_CMD=""
		AUDITAR_BINDIR=""
		USER_AUDITAR=""
		DATE_AUDITAR=""
	fi

	if [ $INICIAR_INSTALLED -eq 0 ] && isIncluded "INICIAR" $1 $2 $3 $4
	then
		INSTALL_INICIAR=0
		INICIAR_CMD=""
		INICIAR_BINDIR=""
		USER_INICIAR=""
		DATE_INICIAR=""
	fi

	if [ $SEGMENTAR_INSTALLED -eq 0 ] && isIncluded "SEGMENTAR" $1 $2 $3 $4
	then
		INSTALL_SEGMENTAR=0
		SEGMENTAR_CMD=""
		SEGMENTAR_BINDIR=""
		USER_SEGMENTAR=""
		DATE_SEGMENTAR=""
	fi

	logDebug "Deshabilitando componentes $1 $2 $3 $4... Done."
}

# Mostrar parametros instalacion.
function showParameters() {
	log "PARAMETROS DE INSTALACION DE Segmentar"
	log "========================================================"
	log "Version de Perl: $1"
	log "Nombre del directorio de instalacion: $2"
	log "Nombre del directorio de configuracion: $3"
	log "Nombre del directorio de ejecutables: $4"
	log "Nombre del directorio de datos: $5"
	log "Nombre del directorio de logs: $6"
	log "Espacio maximo para archivos de logs: $7"
	log "========================================================"
}

# Crear arbol de directorios.
function createFolderTree() {
	log "Creando estructura de directorios..."

	mkdir $BIN_DIR 2> /dev/null
	mkdir $DATA_DIR 2> /dev/null
	mkdir $DATA_DIR/preparados 2> /dev/null
	mkdir $DATA_DIR/preparados/proc 2> /dev/null
	mkdir $DATA_DIR/listos 2> /dev/null
	mkdir $DATA_DIR/listos/proc 2> /dev/null
	mkdir $DATA_DIR/ya 2> /dev/null
	mkdir $DATA_DIR/rechazados 2> /dev/null
	mkdir $LOG_DIR 2> /dev/null
	sleep 1

	log "Creando estructura de directorios... Done."
}

# Mover archivos de instalacion.
function installFiles() {
	log "Moviendo archivos..."
	
	if [ $INSTALL_SEGMENTAR -eq 1 ]
	then
		SEGMENTAR_BINDIR=$BIN_DIR
		cp $COMMANDS_DIR$SEGMENTAR_DEFAULT_CMD $SEGMENTAR_BINDIR/$SEGMENTAR_CMD 2> /dev/null
		RESULT=$(echo $?)

		if [ $RESULT -eq 0 ]
		then
			log "Instalacion del componente SEGMENTAR completada."
		else
			log "Hubo un problema al instalar el componente SEGMENTAR."
			unsetComponentVariables SEGMENTAR
		fi
	fi

	if [ $INSTALL_INICIAR -eq 1 ]
	then
		INICIAR_BINDIR=$BIN_DIR
		cp $COMMANDS_DIR$INICIAR_DEFAULT_CMD $INICIAR_BINDIR/$INICIAR_CMD 2> /dev/null
		RESULT=$(echo $?)

		cp $COMMANDS_DIR$MOVER_CMD $INICIAR_BINDIR/$MOVER_CMD 2> /dev/null
		RESULT_MOVER=$(echo $?)


		if [ $RESULT -eq 0 ] && [ $RESULT_MOVER -eq 0 ]
		then
			log "Instalacion del componente INICIAR completada."
		else
			log "Hubo un problema al instalar el componente INICIAR."
			unsetComponentVariables INICIAR
		fi
	fi

	if [ $INSTALL_AUDITAR -eq 1 ]
	then
		AUDITAR_BINDIR=$BIN_DIR
		cp $COMMANDS_DIR$AUDITAR_DEFAULT_CMD $AUDITAR_BINDIR/$AUDITAR_CMD 2> /dev/null
		RESULT=$(echo $?)

		if [ $RESULT -eq 0 ]
		then
			log "Instalacion del componente AUDITAR completada."
		else
			log "Hubo un problema al instalar el componente AUDITAR."
			unsetComponentVariables AUDITAR
		fi
	fi

	if [ $INSTALL_TRUNCAR -eq 1 ]
	then
		TRUNCAR_BINDIR=$BIN_DIR
		cp $COMMANDS_DIR$TRUNCAR_DEFAULT_CMD $TRUNCAR_BINDIR/$TRUNCAR_CMD 2> /dev/null
		RESULT=$(echo $?)

		if [ $RESULT -eq 0 ]
		then
			log "Instalacion del componente TRUNCAR completada."
		else
			log "Hubo un problema al instalar el componente TRUNCAR."
			unsetComponentVariables TRUNCAR
		fi
	fi

	if [ $INSTALL_DETECTAR -eq 1 ]
	then
		DETECTAR_BINDIR=$BIN_DIR
		cp $COMMANDS_DIR$DETECTAR_DEFAULT_CMD $DETECTAR_BINDIR/$DETECTAR_CMD 2> /dev/null
		RESULT=$(echo $?)

		if [ $RESULT -eq 0 ]
		then
			log "Instalacion del componente DETECTAR completada."
		else
			log "Hubo un problema al instalar el componente DETECTAR."
			unsetComponentVariables DETECTAR
		fi
	fi

	log "Moviendo archivos... Done."
}

# Escribir BINDIR, USERID y FECINS al archivo de configuracion pasado por parametro.
function writeConfigurationParameters() {
	echo "BINDIR = $2" >> $1
	echo "USERID = $3" >> $1
	echo "FECINS = $4" >> $1
}

# Grabar archivo de configuracion.
function saveConfigurationFile() {
	echo "CONFDIR = $CONF_DIR" > $CONF_FILE
	echo "DATADIR = $DATA_DIR" >> $CONF_FILE
	echo "LOGDIR = $LOG_DIR" >> $CONF_FILE
	echo "MAXLOGSIZE = $MAX_LOG_SIZE" >> $CONF_FILE
	echo "UMXLOGSIZE = mb" >> $CONF_FILE
	echo "PERLVER = $PERLVER" >> $CONF_FILE
	echo "" >> $CONF_FILE
	echo "" >> $CONF_FILE
	echo "" >> $CONF_FILE
	echo "TRUNCAR = $TRUNCAR_CMD" >> $CONF_FILE
	writeConfigurationParameters $CONF_FILE $TRUNCAR_BINDIR $USER_TRUNCAR $DATE_TRUNCAR
	echo "SLEEPT = $SLEEP_TRUNCAR" >> $CONF_FILE
	echo "INICIAR = $INICIAR_CMD" >> $CONF_FILE
	writeConfigurationParameters $CONF_FILE $INICIAR_BINDIR $USER_INICIAR $DATE_INICIAR
	echo "" >> $CONF_FILE
	echo "AUDITAR = $AUDITAR_CMD" >> $CONF_FILE
	writeConfigurationParameters $CONF_FILE $AUDITAR_BINDIR $USER_AUDITAR $DATE_AUDITAR
	echo "" >> $CONF_FILE
	echo "DETECTAR = $DETECTAR_CMD" >> $CONF_FILE
	writeConfigurationParameters $CONF_FILE $DETECTAR_BINDIR $USER_DETECTAR $DATE_DETECTAR
	echo "SLEEPD = $SLEEP_DETECTAR" >> $CONF_FILE
	echo "segmentar.pl = $SEGMENTAR_CMD" >> $CONF_FILE
	writeConfigurationParameters $CONF_FILE $SEGMENTAR_BINDIR $USER_SEGMENTAR $DATE_SEGMENTAR
	echo "" >> $CONF_FILE
	echo "FORM_LOG = $FORM_LOG" >> $CONF_FILE
	echo "FORM_ERR = $FORM_ERR" >> $CONF_FILE
	echo "ERR_FILE = $ERR_FILE" >> $CONF_FILE
}

# Mostrar resumen de instalacion.
function showInstalledComponents() {
	log "========================================================"
	log "Proceso de Instalacion Concluido"
	log "Se encuentran instalados los siguientes componentes:"

	if [ $INSTALL_SEGMENTAR -eq 1 ]
	then
		log "Componente segmentar.pl: $SEGMENTAR_BINDIR/$SEGMENTAR_CMD $DATE_SEGMENTAR $USER_SEGMENTAR"
	fi

	if [ $INSTALL_INICIAR -eq 1 ]
	then
		log "Componente INICIAR: $INICIAR_BINDIR/$INICIAR_CMD $DATE_INICIAR $USER_INICIAR"
	fi

	if [ $INSTALL_AUDITAR -eq 1 ]
	then
		log "Componente AUDITAR: $AUDITAR_BINDIR/$AUDITAR_CMD $DATE_AUDITAR $USER_AUDITAR"
	fi

	if [ $INSTALL_TRUNCAR -eq 1 ]
	then
		log "Componente TRUNCAR: $TRUNCAR_BINDIR/$TRUNCAR_CMD $DATE_TRUNCAR $USER_TRUNCAR"
	fi

	if [ $INSTALL_DETECTAR -eq 1 ]
	then
		log "Componente DETECTAR: $DETECTAR_BINDIR/$DETECTAR_CMD $DATE_DETECTAR $USER_DETECTAR"
	fi

	log "Copyrigth TPSistemasOP (c) 2009"
	log "========================================================"
	log "Presione ENTER para finalizar."
	read fin
}

# Uninstall.
function uninstall() {
	log "Eliminando componentes..."
	rm -R $BIN_DIR 2> /dev/null
	rm -R $DATA_DIR 2> /dev/null
	rm -R $LOG_DIR 2> /dev/null
	rm -R $SEGMENTAR_BINDIR 2> /dev/null
	rm -R $INICIAR_BINDIR 2> /dev/null
	rm -R $AUDITAR_BINDIR 2> /dev/null
	rm -R $TRUNCAR_BINDIR 2> /dev/null
	rm -R $DETECTAR_BINDIR 2> /dev/null
	rm -R $CONF_FILE 2> /dev/null
	sleep 1
	log "Eliminando componentes... Done."
	sleep 1

	log ""
	log "========================================================"
	log "Segmentar eliminado correctamente."
	log "Copyrigth TPSistemasOP (c) 2009"
	log "========================================================"
	log "Presione ENTER para finalizar."
	read input
}

###################################################### Funciones - End ######################################################
#############################################################################################################################
clear

# Ayuda
if [ $# -ne 0 ] && [ $1 = "-h" ]
then	
	echo "Uso: instalars [OPTION]"
	echo "	-h Mostrar esta ayuda."
	echo "	-c Verificar componentes de Segmentar instalados."
	echo "	-u Eliminar componentes de Segmentar instalados."
	echo "	-q Quick Install. Instalar Segementar con parametros por defecto."
	echo "	-t Instalar solo el componente TRUNCAR."
	echo "	-d Instalar solo el componente DETECTAR."
	echo "	-a Instalar solo el componente AUDITAR."
	echo "	-i Instalar solo el componente INICIAR."
	echo "	-s Instalar solo el componente SEGMENTAR."
	echo ""
	exit 0
fi

# Verificacion de escritura sobre directorio de logs.
if [ ! -w $CONF_DIR ]
then
	echo $LOG_DEBUG"No se tiene permisos de escritura sobre el directorio de instalacion."
	echo $LOG_DEBUG"Comuniquese con el administrador del sistema para obtener los mismos y reintente luego."
	exit 1
fi

# Inicializacion archivo de logs.
if [ -e $LOG_FILE ]
then
	rm $LOG_FILE
else
	touch $LOG_FILE
fi

# Log inicial.
log "Inicio de Ejecucion."
log "Nombre del directorio de instalacion: ${CURRDIR}inst"
log "Nombre del directorio de configuracion: ${CONF_DIR}"

# Verificar componentes instalados.
checkInstalledComponents

# Uninstall.
if [ $# -ne 0 ] 
then 
	case "$1" in
		"-c") 	logDebug "instalar -c: checkInstalledComponents."
			if [ $INSTALLED -eq 0 ]
			then
				log "Segmentar no se encuentra instalado."
			fi

			log "Fin de Ejecucion."
			exit 0;;

		"-u")	logDebug "instalar -u: uninstallComponents."
			if [ $INSTALLED -eq 1 ]
			then
				if ! promptForConfirmation "Desea elimiar Segmentar y todos sus componentes? (Si) : Si - No"
				then
					logFin
				fi
				uninstall
			else
				log "Segmentar no se encuentra instalado."
			fi

			log "Fin de Ejecucion."
			exit 0;;

		"-t") 	logDebug "instalar -t: installTruncar."
			checkComponentForInstall $TRUNCAR_INSTALLED
			unsetComponentVariables DETECTAR AUDITAR INICIAR SEGMENTAR;;

		"-d") 	logDebug "instalar -d: installDetectar."
			checkComponentForInstall $DETECTAR_INSTALLED
			unsetComponentVariables TRUNCAR AUDITAR INICIAR SEGMENTAR;;

		"-a") 	logDebug "instalar -a: installAuditar."
			checkComponentForInstall $AUDITAR_INSTALLED
			unsetComponentVariables DETECTAR TRUNCAR INICIAR SEGMENTAR;;

		"-i") 	logDebug "instalar -i: installIniciar."
			checkComponentForInstall $INICIAR_INSTALLED
			unsetComponentVariables DETECTAR AUDITAR TRUNCAR SEGMENTAR;;

		"-s") 	logDebug "instalar -s: installSegmentar."
			checkComponentForInstall $SEGMENTAR_INSTALLED
			unsetComponentVariables DETECTAR AUDITAR INICIAR TRUNCAR;;

		 "-q") 	logDebug "instalar -q: quickInstall."
			# Si esta todo instalado se cancela la instalacion.
			if [ $ALL_INSTALLED -eq 1 ]
			then
				logFin
			else
				QUICK_INSTALL=1
			fi;;

		   *) 	logDebug "instalar $1: badOption."
			log "Opcion Invalida."
			log "Usar 'instalars -h' para mas informacion."
			logFin;;
	esac
else
	# Si esta todo instalado se cancela la instalacion.
	if [ $ALL_INSTALLED -eq 1 ]
	then
		logFin
	fi

	# Proponer instalar componentes faltantes.
	if [ $INSTALLED -eq 1 ] && ! promptForConfirmation "Instalar Componentes Faltantes? (Si) : Si - No"
	then
		logFin
	else
		clear
	fi
fi

# Mostrar terminos y condiciones.
showTermsAndConditions

# Aceptacion de terminos y condiciones
if ! promptForConfirmation "Acepta? (Si) : Si - No"
then
	logFin
fi

# Verificar version de Perl instalada.
checkPerlVersion

INSTALAR=0
while [ $INSTALAR -ne 1 ]
do
	if [ $QUICK_INSTALL -eq 0 ]
	then
		checkDataFolder
		checkDataFolderSpace
		checkLogFolder
		checkMaxLogSize	$MAX_LOG_SIZE
		checkExecutableFolder
	else
		calculateFreeSpace $CURRDIR
		DATA_SIZE=$free_space
		MAX_LOG_SIZE=`echo "$DATA_SIZE / 10" | bc`
	fi
	
	# Mostrar parametros de instalacion.
	clear
	showParameters $PERLVER $(pwd) $CONF_DIR $BIN_DIR $DATA_DIR $LOG_DIR $MAX_LOG_SIZE
	if promptForConfirmation "Continuar Instalacion? (Si) : Si - No"
	then
		INSTALAR=1
	else
		clear
		if [ $QUICK_INSTALL -ne 0 ]
		then
			logFin
		fi
	fi
done

# Creacion de directorios.
createFolderTree

# Movimiento de archivos.
installFiles

# Grabar archivo de configuracion.
saveConfigurationFile
sleep 2


# Informe de instalacion.
clear
showInstalledComponents
log "Fin de Ejecucion."

exit 0
